/**
 * 获取新闻类别
 * @returns {Array<{id: string, name: string}>} 新闻类别数组
 */
const getNewsCategories = () => {
    return [
        { id: 'technology', name: '科技' },
        { id: 'business', name: '商业' },
        { id: 'entertainment', name: '娱乐' },
        { id: 'health', name: '健康' },
        { id: 'science', name: '科学' },
        { id: 'sports', name: '体育' },
        { id: 'education', name: '教育' },
        { id: 'travel', name: '旅游' },
        { id: 'food', name: '美食' },
        { id: 'automobile', name: '汽车' },
        { id: 'fashion', name: '时尚' },
        { id: 'games', name: '游戏' },
        { id: 'finance', name: '财经' },
        { id: 'military', name: '军事' },
        { id: 'culture', name: '文化' },
        { id: 'environment', name: '环境' }
    ];
};

// 获取用户历史记录
const getHistory = () => {
    const history = localStorage.getItem('newsHistory');
    return history ? JSON.parse(history) : [];
};

// 保存历史记录
const saveHistory = (history) => {
    localStorage.setItem('newsHistory', JSON.stringify(history));
};

// 添加历史记录
const addHistory = (category) => {
    const history = getHistory();
    if (!history.includes(category)) {
        history.unshift(category);
        // 只保留最近10条记录
        if (history.length > 10) {
            history.pop();
        }
        saveHistory(history);
        updateHistoryDisplay();
    }
};

// 更新历史记录显示
const updateHistoryDisplay = () => {
    const history = getHistory();
    const historyElement = document.getElementById('historyList');
    
    if (!historyElement) return;
    
    if (history.length === 0) {
        historyElement.innerHTML = '<p class="text-muted">暂无浏览记录</p>';
        return;
    }
    
    let html = '<div class="list-group">';
    history.forEach(category => {
        html += `
            <div class="list-group-item d-flex justify-content-between align-items-center">
                <a href="#" class="view-category" data-category="${category}">${category}新闻</a>
                <button class="btn btn-sm btn-outline-danger" onclick="removeHistory('${category}', event)">
                    <i class="fas fa-times"></i>
                </button>
            </div>
        `;
    });
    html += '</div>';
    
    historyElement.innerHTML = html;
};

/**
 * 删除指定历史记录
 * @param {string} category - 要删除的类别
 * @param {Event} event - 事件对象
 */
const removeHistory = (category, event) => {
    if (event) {
        event.stopPropagation();
    }
    const history = getHistory();
    const index = history.indexOf(category);
    if (index > -1) {
        history.splice(index, 1);
        saveHistory(history);
        updateHistoryDisplay();
    }
};

// 清除所有历史记录
const clearAllHistory = () => {
    if (confirm('确定要清除所有历史记录吗？')) {
        localStorage.removeItem('newsHistory');
        updateHistoryDisplay();
    }
};

/**
 * 获取新闻数据
 * @param {string} category - 新闻类别
 * @returns {Promise<Array>} 新闻数据
 */
const fetchNews = async (category) => {
    // 这里可以添加获取新闻的逻辑
    return [];
};

// 初始化事件监听器
const initEventListeners = () => {
    console.log('事件监听器已初始化');
    
    // 类别点击事件
    document.addEventListener('click', (e) => {
        const categoryLink = e.target.closest('.category-link');
        if (categoryLink) {
            const category = categoryLink.dataset.category;
            if (category) {
                addHistory(category);
                // 这里不阻止默认行为，让链接正常跳转
            }
        }
        
        if (e.target.classList.contains('view-category')) {
            e.preventDefault();
            const category = e.target.dataset.category;
            if (category) {
                addHistory(category);
                viewCategoryNews(category);
            }
        }
    });

    // 新闻详情点击事件
    document.addEventListener('click', (e) => {
        if (e.target.classList.contains('view-article')) {
            e.preventDefault();
            const url = e.target.dataset.url;
            if (url) {
                viewArticleDetails(url);
            }
        }
    });
    
    // 初始化清除历史按钮
    const clearHistoryBtn = document.getElementById('clearHistoryBtn');
    if (clearHistoryBtn) {
        clearHistoryBtn.addEventListener('click', clearAllHistory);
    }
};

// 初始化新闻平台
const initNewsPlatform = async () => {
    try {
        console.log('开始初始化新闻平台...');
        // 初始化新闻类别
        await initCategories();
        // 初始化推荐新闻
        await initRecommendations();
        // 初始化事件监听器
        initEventListeners();
        // 初始化搜索功能
        initSearchFunctionality();
        console.log('新闻平台初始化完成');
    } catch (error) {
        console.error('初始化新闻平台失败:', error);
        alert('系统初始化失败，请稍后重试');
    }
};

// 初始化搜索功能
const initSearchFunctionality = () => {
    const searchForm = document.getElementById('newsSearchForm');
    if (searchForm) {
        // 移除旧的事件监听器（如果存在）
        const newSearchForm = searchForm.cloneNode(true);
        searchForm.parentNode.replaceChild(newSearchForm, searchForm);
        
        newSearchForm.addEventListener('submit', (e) => {
            e.preventDefault();
            
            const category = document.getElementById('categoryInput')?.value;
            
            // 验证输入
            if (!category) {
                alert('请输入新闻类别');
                return;
            }

            // 将搜索关键词添加到浏览历史
            addHistory(category);
            
            // 构建百度新闻搜索URL
            const baiduSearchUrl = `https://news.baidu.com/ns?word=${encodeURIComponent(`新闻 ${category}`)}&tn=newssearch`;
            
            // 直接跳转到百度搜索结果页
            window.location.href = baiduSearchUrl;
        });
        
        console.log('搜索功能已初始化');
    } else {
        console.warn('未找到搜索表单');
    }
};

/**
 * 初始化新闻类别
 * @returns {Promise<void>}
 */
const initCategories = async () => {
    try {
        console.log('开始初始化新闻类别...');
        
        // 定义类别对应的百度新闻链接
        const categoryLinks = {
            '科技': 'https://www.baidu.com/s?ie=utf-8&medium=0&rtt=1&bsst=1&rsv_dl=news_t_sk&cl=2&wd=科技新闻&tn=news&rsv_bp=1&rsv_sug3=26&rsv_sug1=6&rsv_sug7=101&oq=&rsv_sug2=0&rsv_btype=t&f=8&inputT=8078&rsv_sug4=8990',
            '体育': 'https://www.baidu.com/s?rtt=1&bsst=1&cl=2&tn=news&rsv_dl=ns_pc&word=体育新闻',
            '国际': 'https://www.baidu.com/s?ie=utf-8&medium=0&rtt=1&bsst=1&rsv_dl=news_t_sk&cl=2&wd=国际新闻&tn=news&rsv_bp=1&rsv_sug3=9&rsv_sug1=3&rsv_sug7=100&oq=&rsv_sug2=0&rsv_btype=t&f=8&inputT=3278&rsv_sug4=4007',
            '娱乐': 'https://www.baidu.com/s?ie=utf-8&medium=0&rtt=1&bsst=1&rsv_dl=news_t_sk&cl=2&wd=娱乐新闻&tn=news&rsv_bp=1&rsv_sug3=7&rsv_sug1=2&rsv_sug7=100&oq=&rsv_sug2=0&rsv_btype=t&f=8&prefixsug=%25E5%25A8%25B1%25E4%25B9%2590%25E6%2596%25B0%25E9%2597%25BB&rsp=1&inputT=2318&rsv_sug4=2926&rsv_sug=1'
        };
        
        // 添加类别点击事件
        document.querySelectorAll('.category-link').forEach(link => {
            const category = link.getAttribute('data-category');
            if (category && categoryLinks[category]) {
                // 直接设置链接地址，不再需要点击事件
                link.href = categoryLinks[category];
                // 设置在新标签页打开
                link.target = '_blank';
            }
        });
        
        console.log('新闻类别初始化完成');
    } catch (error) {
        console.error('初始化新闻类别失败:', error);
        throw error;
    }
};

/**
 * 初始化推荐新闻
 * @returns {Promise<void>}
 */
const initRecommendations = async () => {
    try {
        console.log('开始初始化推荐新闻...');
        // 不需要动态生成推荐新闻，因为已经在HTML中硬编码了
        
        // 添加复制功能
        document.querySelectorAll('.copy-news').forEach(button => {
            button.addEventListener('click', (e) => {
                e.preventDefault();
                const title = button.dataset.title;
                const content = button.dataset.content;
                const textToCopy = `${title}\n${content}`;
                
                navigator.clipboard.writeText(textToCopy).then(() => {
                    const originalText = button.innerHTML;
                    button.innerHTML = '<i class="bi bi-check"></i> 已复制';
                    button.classList.remove('btn-outline-secondary');
                    button.classList.add('btn-success');
                    
                    setTimeout(() => {
                        button.innerHTML = originalText;
                        button.classList.remove('btn-success');
                        button.classList.add('btn-outline-secondary');
                    }, 2000);
                }).catch(err => {
                    console.error('复制失败:', err);
                });
            });
        });
        
        console.log('推荐新闻初始化完成');
    } catch (error) {
        console.error('初始化推荐新闻失败:', error);
        throw error;
    }
};

// Serper API 配置
const SERPER_API_KEY = 'ca8e28d9adc5c0db30fea2ae1090a12547bd21ad';
const SERPER_API_URL = 'https://google.serper.dev/search';

// LM Studio 服务器配置
const LM_STUDIO_CONFIG = {
    baseUrl: 'http://localhost:1234', // 默认本地LM Studio地址
    endpoints: {
        chat: '/v1/chat/completions',
        models: '/v1/models'
    },
    model: 'local-model', // 本地模型名称
    temperature: 0.7,
    max_tokens: 1000,
    // 添加备用回复，当LM Studio不可用时使用
    fallbackReplies: [
        "您好！我是AI助手，目前无法连接到本地模型服务。请确保LM Studio正在运行并监听1234端口。",
        "我暂时无法处理您的请求。请检查LM Studio是否已正确启动。",
        "抱歉，服务暂时不可用。请稍后再试。"
    ]
};

/**
 * 使用LM Studio处理消息
 * @param {string} message 用户消息
 * @param {Array} conversationHistory 对话历史
 * @returns {Promise<string>} AI回复
 */
const processWithLMStudio = async (message, conversationHistory = []) => {
    try {
        // 构建消息历史
        const messages = [
            {
                role: 'system',
                content: '你是星脉AI新闻分析助手，专门帮助用户理解和分析新闻内容。请提供准确、客观的新闻分析和相关信息。'
            },
            ...conversationHistory,
            { role: 'user', content: message }
        ];

        const response = await fetch(`${LM_STUDIO_CONFIG.baseUrl}${LM_STUDIO_CONFIG.endpoints.chat}`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                model: LM_STUDIO_CONFIG.model,
                messages: messages,
                temperature: LM_STUDIO_CONFIG.temperature,
                max_tokens: LM_STUDIO_CONFIG.max_tokens,
                stream: false
            })
        });

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();
        return data.choices[0]?.message?.content || getFallbackReply();
    } catch (error) {
        console.error('调用LM Studio API失败:', error);
        return getFallbackReply();
    }
};

/**
 * 获取回退回复
 * @returns {string} 回退回复
 */
const getFallbackReply = () => {
    return LM_STUDIO_CONFIG.fallbackReplies[
        Math.floor(Math.random() * LM_STUDIO_CONFIG.fallbackReplies.length)
    ];
};


// 检查 LM Studio 服务器是否可用
let checkLocalModel = async () => {
    const url = `${LM_STUDIO_CONFIG.baseUrl}${LM_STUDIO_CONFIG.endpoints.models}`;
    console.log('正在检查 LM Studio 服务器:', url);
    
    try {
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Content-Type': 'application/json'
            },
            mode: 'cors' // 添加 CORS 模式
        });
        
        console.log('服务器响应状态:', response.status, response.statusText);
        
        if (!response.ok) {
            const errorText = await response.text();
            console.error('服务器返回错误:', errorText);
            return false;
        }
        
        const data = await response.json();
        console.log('可用的模型:', data);
        return true;
        
    } catch (error) {
        console.error('无法连接到 LM Studio 服务器:', error);
        console.error('错误详情:', {
            name: error.name,
            message: error.message,
            stack: error.stack
        });
        return false;
    }
};

// 显示API不可用提示
/**
 * 显示API不可用提示
 */
const showApiUnavailableMessage = () => {
    const alertDiv = document.createElement('div');
    alertDiv.className = 'alert alert-warning alert-dismissible fade show position-fixed top-0 end-0 m-3';
    alertDiv.role = 'alert';
    alertDiv.style.zIndex = '2000';
    
    alertDiv.innerHTML = `
        <strong>提示：</strong> 当前API不可用，部分功能可能受限。
        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
    `;
    
    document.body.appendChild(alertDiv);
};

// 初始化历史记录功能
const initHistory = () => {
    // 为类别链接添加点击事件
    document.querySelectorAll('.category-link').forEach(link => {
        link.addEventListener('click', (e) => {
            const category = e.target.closest('.category-link').dataset.category;
            if (category) {
                addHistory(category);
            }
        });
    });
    
    console.log('历史记录功能已初始化');
};

/**
 * 初始化联系表单
 */
const initContactForm = () => {
    const contactForm = document.querySelector('#contact form');
    if (!contactForm) return;

    contactForm.addEventListener('submit', async (e) => {
        e.preventDefault();
        
        // 获取表单数据
        const name = document.getElementById('name').value.trim();
        const email = document.getElementById('email').value.trim();
        const message = document.getElementById('message').value.trim();
        
        // 简单表单验证
        if (!name) {
            alert('请输入您的姓名');
            return;
        }
        
        if (!email) {
            alert('请输入您的邮箱');
            return;
        } else if (!/^\S+@\S+\.\S+$/.test(email)) {
            alert('请输入有效的邮箱地址');
            return;
        }
        
        if (!message) {
            alert('请输入您的消息内容');
            return;
        }
        
        try {
            const submitBtn = contactForm.querySelector('button[type="submit"]');
            const originalText = submitBtn.textContent;
            submitBtn.disabled = true;
            submitBtn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 发送中...';
            
            try {
                // 使用 EmailJS 发送邮件
                const templateParams = {
                    from_name: name,
                    from_email: email,
                    message: message,
                    to_email: '1545723153@qq.com',  // 收件人邮箱
                    reply_to: email  // 添加回复地址
                };


                // 发送邮件
                await emailjs.send(
                    'service_i06ln9w',    // 您的 EmailJS 服务ID
                    'template_88drq7c',    // 您的 EmailJS 模板ID
                    templateParams,
                    'DnSeHouzFWQnIQKoT'    // 您的 EmailJS 公钥
                );
                
                console.log('邮件发送成功');
                
                // 显示成功消息
                alert('感谢您的留言！我们会尽快与您联系。');
                
                // 重置表单
                contactForm.reset();
            } catch (error) {
                console.error('发送邮件失败:', error);
                alert('发送失败，请稍后重试或直接联系：1545723153@qq.com');
            }
            
        } catch (error) {
            console.error('提交表单时出错:', error);
            alert('提交失败，请稍后重试');
        } finally {
            const submitBtn = contactForm.querySelector('button[type="submit"]');
            if (submitBtn) {
                submitBtn.disabled = false;
                submitBtn.textContent = '发送';
            }
        }
    });
};

// 页面加载时初始化
document.addEventListener('DOMContentLoaded', async () => {
    console.log('DOM已加载，开始初始化...');
    
    // 初始化联系表单
    initContactForm();
    
    try {
        // 初始化历史记录显示
        updateHistoryDisplay();
        // 初始化历史记录功能
        initHistory();
        // 初始化AI助手（在所有页面上都初始化）
        console.log('正在初始化AI助手...');
        initAIAssistant();
        
        // 检查当前页面
        if (window.location.pathname.endsWith('news.html')) {
            console.log('检测到新闻详情页，初始化新闻详情页...');
            initNewsDetailPage();
            return;
        }
        
        console.log('开始初始化首页功能...');
        
        // 检查本地模型可用性
        console.log('开始检查本地模型可用性...');
        const isLocalModelAvailable = await checkLocalModel();
        console.log('本地模型可用性检查结果:', isLocalModelAvailable);
        
        if (!isLocalModelAvailable) {
            console.warn('本地模型不可用，显示错误信息');
            showApiUnavailableMessage();
        } else {
            console.log('本地模型可用，继续初始化...');
        }

        // 初始化主要功能
        console.log('正在初始化新闻平台...');
        await initNewsPlatform();
        
        console.log('正在初始化复制按钮...');
        initCopyButtons();
        
        // 初始化事件监听器
        initEventListeners();
        
        console.log('所有功能初始化完成！');
        
        // 检查是否有需要分析的新闻
        const newsToAnalyze = localStorage.getItem('newsToAnalyze');
        if (newsToAnalyze) {
            try {
                const { title, content, timestamp } = JSON.parse(newsToAnalyze);
                // 清除存储的数据，避免重复处理
                localStorage.removeItem('newsToAnalyze');
                
                // 检查数据是否过期（1小时内有效）
                if (Date.now() - timestamp < 3600000) {
                    // 显示分析结果
                    const analysisResult = await analyzeNewsContent(title, content);
                    showNewsAnalysis(analysisResult);
                    
                    // 自动发送分析请求
                    setTimeout(() => {
                        const userInput = document.getElementById('userInput');
                        const sendButton = document.getElementById('sendMessage');
                        if (userInput && sendButton) {
                            userInput.value = `请分析这篇新闻：${title}`;
                            sendButton.click();
                        }
                    }, 1000);
                }
            } catch (e) {
                console.error('处理新闻分析时出错:', e);
            } finally {
                // 清除存储的数据
                localStorage.removeItem('newsToAnalyze');
            }
        }
    } catch (error) {
        console.error('初始化失败:', error);
        // 显示友好的错误提示
        const errorDiv = document.createElement('div');
        errorDiv.className = 'alert alert-danger m-3';
        errorDiv.textContent = '系统初始化失败，请刷新页面重试。如果问题持续存在，请联系管理员。';
        document.body.prepend(errorDiv);
    }
});

// 初始化新闻详情页
/**
 * 初始化新闻详情页
 * @returns {Promise<void>}
 */
const initNewsDetailPage = async () => {
    // 获取新闻内容
    const getNewsContent = () => {
        const titleElement = document.getElementById('newsTitle');
        const title = titleElement ? titleElement.textContent : '当前新闻';
        // 获取新闻内容，优先从.content元素获取，如果没有则从#newsContent获取
        const contentElement = document.querySelector('.content') || document.querySelector('#newsContent');
        const content = contentElement?.textContent?.trim() || '';
        return { title, content };
    };
    
    // 设置AI分析按钮点击事件
    const analyzeBtn = document.getElementById('analyzeNews');
    if (analyzeBtn) {
        analyzeBtn.addEventListener('click', async () => {
            const { title, content } = getNewsContent();
            if (!content) {
                alert('无法获取新闻内容，请稍后再试');
                return;
            }
            
            // 存储新闻内容到本地存储，以便首页使用
            localStorage.setItem('newsToAnalyze', JSON.stringify({ 
                title, 
                content: content.substring(0, 1000),
                timestamp: Date.now()
            }));
            
            // 跳转到首页
            window.location.href = 'index.html#chatbot';
        });
        
        // 初始禁用按钮，等待内容加载完成
        analyzeBtn.disabled = true;
        analyzeBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-2"></i>加载中...';
        
        // 检查内容是否加载完成
        const checkContentLoaded = () => {
            const { content } = getNewsContent();
            if (content) {
                analyzeBtn.disabled = false;
                analyzeBtn.innerHTML = '<i class="fas fa-robot me-2"></i>AI分析';
            } else {
                setTimeout(checkContentLoaded, 500);
            }
        };
        
        // 开始检查内容加载状态
        checkContentLoaded();
    }
};

// 初始化复制按钮
const initCopyButtons = () => {
    document.addEventListener('click', async (e) => {
        if (e.target.closest('.copy-news')) {
            const button = e.target.closest('.copy-news');
            const title = button.dataset.title;
            const content = button.dataset.content;
            
            try {
                // 复制内容到剪贴板
                await navigator.clipboard.writeText(`${title}\n\n${content}`);
                
                // 更新按钮文本和样式
                const originalText = button.innerHTML;
                button.innerHTML = '<i class="bi bi-check"></i> 已复制';
                button.classList.remove('btn-outline-secondary');
                button.classList.add('btn-success');
                
                // 3秒后恢复原状
                setTimeout(() => {
                    button.innerHTML = originalText;
                    button.classList.remove('btn-success');
                    button.classList.add('btn-outline-secondary');
                }, 2000);
                
                // 如果客服对话框未打开，则打开它
                const chatbotContainer = document.getElementById('chatbotContainer');
                if (chatbotContainer) {
                    chatbotContainer.classList.add('show');
                    
                    // 自动将内容发送给AI分析
                    setTimeout(() => {
                        const userInput = document.getElementById('userInput');
                        if (userInput) {
                            userInput.value = `请分析这篇新闻：\n标题：${title}\n内容：${content}`;
                            document.getElementById('sendMessage').click();
                        }
                    }, 500);
                }
            } catch (err) {
                console.error('复制失败:', err);
                alert('复制失败，请手动选择并复制文本');
            }
        }
    });
};

// 注：在线客服功能已迁移至AI新闻助手

// ====================================
// AI 新闻助手功能
// ====================================

// AI 助手配置
const AI_ASSISTANT_CONFIG = {
    model: 'local-model',
    temperature: 0.7,
    maxTokens: 1000
};

// 预设问题
const PRESET_QUESTIONS = [
    "今天有什么重要新闻？",
    "帮我总结这篇新闻的主要内容",
    "关于科技领域的最新动态有哪些？",
    "最近有什么热门话题？",
    "推荐几篇值得一读的文章"
];

// 对话历史
let conversationHistory = [];

/**
 * 初始化AI助手
 */
const initAIAssistant = () => {
    // 加载对话历史
    loadConversation();
    
    // 发送消息
    const chatForm = document.getElementById('chat-form');
    if (chatForm) {
        chatForm.addEventListener('submit', handleChatSubmit);
    }
    
    // 清空对话
    const clearChatBtn = document.getElementById('clearChatBtn');
    if (clearChatBtn) {
        clearChatBtn.addEventListener('click', clearConversation);
    }
    
    // 输入框自动调整高度
    const userInput = document.getElementById('user-input');
    if (userInput) {
        userInput.addEventListener('input', autoResize);
    }
    
    // 添加预设问题
    addPresetQuestions();
};

/**
 * 添加预设问题
 */
const addPresetQuestions = () => {
    const container = document.createElement('div');
    container.className = 'preset-questions mt-3';
    container.innerHTML = `
        <div class="d-flex flex-wrap gap-2 mb-2">
            <small class="w-100 text-muted">快速提问：</small>
            ${PRESET_QUESTIONS.map(q => `
                <button type="button" class="btn btn-sm btn-outline-primary preset-question">
                    ${q}
                </button>
            `).join('')}
        </div>
    `;
    
    // 插入到输入框上方
    const chatForm = document.getElementById('chat-form');
    if (chatForm) {
        chatForm.parentNode.insertBefore(container, chatForm);
        
        // 添加点击事件
        container.querySelectorAll('.preset-question').forEach(btn => {
            btn.addEventListener('click', (e) => {
                e.preventDefault();
                const question = btn.textContent.trim();
                document.getElementById('user-input').value = question;
                document.getElementById('user-input').focus();
            });
        });
    }
};

/**
 * 处理聊天表单提交
 */
const handleChatSubmit = async (e) => {
    e.preventDefault();
    
    const userInput = document.getElementById('user-input');
    const message = userInput.value.trim();
    
    if (!message) return;
    
    // 添加用户消息到界面
    addMessage('user', message);
    
    // 清空输入框
    userInput.value = '';
    autoResize({ target: userInput });
    
    // 显示加载状态
    const sendBtn = document.querySelector('#chat-form button[type="submit"]');
    const sendText = document.getElementById('send-text');
    const sendingText = document.getElementById('sending-text');
    
    sendBtn.disabled = true;
    sendText.classList.add('d-none');
    sendingText.classList.remove('d-none');
    
    try {
        // 添加到对话历史
        conversationHistory.push({ role: 'user', content: message });
        
        let aiResponse;
        
        // 检查是否需要联网搜索
        if (shouldSearchWeb(message)) {
            // 使用网络搜索获取最新信息
            aiResponse = await getSearchBasedResponse(message);
            
            // 将AI回复添加到对话历史
            conversationHistory.push({ role: 'assistant', content: aiResponse });
            
            // 直接显示回复（不使用打字效果，因为可能包含链接）
            addMessage('assistant', aiResponse);
        } else {
            // 使用本地知识库回答
            aiResponse = await getAIResponse(conversationHistory);
            
            // 添加AI回复到界面（使用打字效果）
            await addMessageWithTypingEffect('assistant', aiResponse);
        }
        
        // 保存对话历史
        saveConversation();
        
    } catch (error) {
        console.error('获取AI回复失败:', error);
        addMessage('assistant', '抱歉，我遇到了一些问题，请稍后再试。');
    } finally {
        // 重置按钮状态
        sendBtn.disabled = false;
        sendText.classList.remove('d-none');
        sendingText.classList.add('d-none');
    }
};

/**
 * 获取AI回复
 * @param {Array} messages - 消息历史
 * @returns {Promise<string>} AI回复内容
 */
const getAIResponse = async (messages) => {
    try {
        // 提取用户消息（最后一条消息）
        const userMessage = messages[messages.length - 1];
        
        // 构建对话历史，排除系统消息
        const conversationHistory = messages
            .filter(msg => msg.role !== 'system')
            .map(msg => ({
                role: msg.role === 'user' ? 'user' : 'assistant',
                content: msg.content
            }));
        
        // 使用LM Studio处理消息
        const aiMessage = await processWithLMStudio(userMessage.content, conversationHistory);
        
        // 添加到对话历史
        conversationHistory.push({ role: 'assistant', content: aiMessage });
        
        return aiMessage;
        
    } catch (error) {
        console.error('获取AI回复失败:', error);
        throw error;
    }
};

/**
 * 添加带打字效果的消息
 */
const addMessageWithTypingEffect = async (sender, content) => {
    const chatMessages = document.getElementById('chat-messages');
    if (!chatMessages) return;
    
    // 移除欢迎消息（如果是第一条消息）
    if (chatMessages.children.length === 1 && 
        chatMessages.children[0].classList.contains('text-muted')) {
        chatMessages.innerHTML = '';
    }
    
    const messageDiv = document.createElement('div');
    messageDiv.className = `mb-3 ${sender}-message`;
    
    const messageContent = document.createElement('div');
    messageContent.className = `d-flex ${sender === 'user' ? 'justify-content-end' : 'justify-content-start'}`;
    
    const messageBubble = document.createElement('div');
    messageBubble.className = `p-3 rounded-3 ${
        sender === 'user' 
            ? 'bg-primary text-white' 
            : 'bg-light'
    }`;
    messageBubble.style.maxWidth = '80%';
    
    // 添加消息内容容器
    const messageText = document.createElement('div');
    messageText.className = 'message-text';
    messageBubble.appendChild(messageText);
    
    // 添加时间戳
    const timeDiv = document.createElement('div');
    timeDiv.className = 'text-end mt-2';
    timeDiv.style.fontSize = '0.75rem';
    timeDiv.style.opacity = '0.7';
    timeDiv.textContent = formatTime();
    messageBubble.appendChild(timeDiv);
    
    // 添加头像
    const avatar = document.createElement('div');
    avatar.className = `rounded-circle d-flex align-items-center justify-content-center ${
        sender === 'user' ? 'ms-2 order-1' : 'me-2'
    }`;
    avatar.style.width = '36px';
    avatar.style.height = '36px';
    avatar.style.flexShrink = '0';
    avatar.style.backgroundColor = sender === 'user' ? '#0d6efd' : '#6c757d';
    
    const icon = document.createElement('i');
    icon.className = sender === 'user' ? 'fas fa-user text-white' : 'fas fa-robot text-white';
    
    avatar.appendChild(icon);
    
    if (sender === 'user') {
        messageContent.appendChild(messageBubble);
        messageContent.appendChild(avatar);
    } else {
        messageContent.appendChild(avatar);
        messageContent.appendChild(messageBubble);
    }
    
    messageDiv.appendChild(messageContent);
    chatMessages.appendChild(messageDiv);
    
    // 滚动到底部
    chatMessages.scrollTop = chatMessages.scrollHeight;
    
    // 如果是AI消息，添加打字效果
    if (sender === 'assistant') {
        await typeWriter(messageText, content);
    } else {
        messageText.textContent = content;
    }
    
    return messageDiv;
};

/**
 * 添加消息到聊天界面
 */
const addMessage = (sender, content) => {
    const chatMessages = document.getElementById('chat-messages');
    if (!chatMessages) return;
    
    // 移除欢迎消息（如果是第一条消息）
    if (chatMessages.children.length === 1 && 
        chatMessages.children[0].classList.contains('text-muted')) {
        chatMessages.innerHTML = '';
    }
    
    const messageDiv = document.createElement('div');
    messageDiv.className = `mb-3 ${sender}-message`;
    
    const messageContent = document.createElement('div');
    messageContent.className = `d-flex ${sender === 'user' ? 'justify-content-end' : 'justify-content-start'}`;
    
    const messageBubble = document.createElement('div');
    messageBubble.className = `p-3 rounded-3 ${
        sender === 'user' 
            ? 'bg-primary text-white' 
            : 'bg-light'
    }`;
    messageBubble.style.maxWidth = '80%';
    
    // 处理换行符
    const formattedContent = content.replace(/\n/g, '<br>');
    messageBubble.innerHTML = formattedContent;
    
    // 添加时间戳
    const timeDiv = document.createElement('div');
    timeDiv.className = 'text-end mt-2';
    timeDiv.style.fontSize = '0.75rem';
    timeDiv.style.opacity = '0.7';
    timeDiv.textContent = formatTime();
    messageBubble.appendChild(timeDiv);
    
    // 添加头像
    const avatar = document.createElement('div');
    avatar.className = `rounded-circle d-flex align-items-center justify-content-center ${
        sender === 'user' ? 'ms-2 order-1' : 'me-2'
    }`;
    avatar.style.width = '36px';
    avatar.style.height = '36px';
    avatar.style.flexShrink = '0';
    avatar.style.backgroundColor = sender === 'user' ? '#0d6efd' : '#6c757d';
    
    const icon = document.createElement('i');
    icon.className = sender === 'user' ? 'fas fa-user text-white' : 'fas fa-robot text-white';
    
    avatar.appendChild(icon);
    
    if (sender === 'user') {
        messageContent.appendChild(messageBubble);
        messageContent.appendChild(avatar);
    } else {
        messageContent.appendChild(avatar);
        messageContent.appendChild(messageBubble);
    }
    
    messageDiv.appendChild(messageContent);
    chatMessages.appendChild(messageDiv);
    
    // 滚动到底部
    chatMessages.scrollTop = chatMessages.scrollHeight;
    
    return messageDiv;
};

/**
 * 打字机效果
 */
const typeWriter = async (element, text, speed = 20) => {
    return new Promise(resolve => {
        let i = 0;
        const typingCursor = document.createElement('span');
        typingCursor.className = 'typing-cursor';
        typingCursor.textContent = '|';
        element.appendChild(typingCursor);
        
        function type() {
            if (i < text.length) {
                // 移除光标
                if (typingCursor.parentNode === element) {
                    element.removeChild(typingCursor);
                }
                
                // 添加新字符
                element.innerHTML += text.charAt(i);
                
                // 重新添加光标
                element.appendChild(typingCursor);
                
                i++;
                setTimeout(type, speed);
                
                // 滚动到底部
                const chatMessages = document.getElementById('chat-messages');
                if (chatMessages) {
                    chatMessages.scrollTop = chatMessages.scrollHeight;
                }
            } else {
                // 完成时移除光标
                if (typingCursor.parentNode === element) {
                    element.removeChild(typingCursor);
                }
                resolve();
            }
        }
        
        type();
    });
};

/**
 * 格式化时间
 */
const formatTime = (date = new Date()) => {
    return date.toLocaleTimeString([], { 
        hour: '2-digit', 
        minute: '2-digit',
        hour12: false
    });
};

/**
 * 保存对话历史到本地存储
 */
const saveConversation = () => {
    try {
        localStorage.setItem('aiAssistantConversation', JSON.stringify(conversationHistory));
    } catch (error) {
        console.error('保存对话历史失败:', error);
    }
};

/**
 * 从本地存储加载对话历史
 */
const loadConversation = () => {
    try {
        const savedConversation = localStorage.getItem('aiAssistantConversation');
        if (savedConversation) {
            conversationHistory = JSON.parse(savedConversation);
            
            // 清空当前消息
            const chatMessages = document.getElementById('chat-messages');
            if (chatMessages) {
                chatMessages.innerHTML = '';
                
                // 重新添加所有消息
                const addMessagesSequentially = async () => {
                    for (const msg of conversationHistory) {
                        if (msg.role === 'assistant') {
                            await addMessageWithTypingEffect(msg.role, msg.content);
                        } else {
                            addMessage(msg.role, msg.content);
                        }
                        // 添加小延迟使消息显示更自然
                        await new Promise(resolve => setTimeout(resolve, 100));
                    }
                };
                
                addMessagesSequentially();
                
                // 如果没有消息，显示欢迎消息
                if (conversationHistory.length === 0) {
                    chatMessages.innerHTML = `
                        <div class="text-center text-muted py-5">
                            <i class="fas fa-comments fa-3x mb-3"></i>
                            <p>我是您的AI新闻助手，请问有什么可以帮您？</p>
                        </div>
                    `;
                }
            }
        }
    } catch (error) {
        console.error('加载对话历史失败:', error);
    }
};

/**
 * 清空对话
 */
const clearConversation = () => {
    if (confirm('确定要清空对话历史吗？此操作不可撤销。')) {
        conversationHistory = [];
        saveConversation();
        
        const chatMessages = document.getElementById('chat-messages');
        if (chatMessages) {
            chatMessages.innerHTML = `
                <div class="text-center text-muted py-5">
                    <i class="fas fa-comments fa-3x mb-3"></i>
                    <p>我是您的AI新闻助手，请问有什么可以帮您？</p>
                </div>
            `;
        }
    }
};

/**
 * 自动调整输入框高度
 */
const autoResize = (e) => {
    const textarea = e.target;
    textarea.style.height = 'auto';
    textarea.style.height = (textarea.scrollHeight) + 'px';
};

/**
 * 使用 Serper API 搜索网页
 * @param {string} query - 搜索查询
 * @returns {Promise<Object>} 搜索结果
 */
async function searchWithSerper(query) {
    try {
        const response = await fetch(SERPER_API_URL, {
            method: 'POST',
            headers: {
                'X-API-KEY': SERPER_API_KEY,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                q: query,
                gl: 'cn',
                hl: 'zh-cn'
            })
        });

        if (!response.ok) {
            throw new Error(`搜索失败: ${response.status} ${response.statusText}`);
        }

        return await response.json();
    } catch (error) {
        console.error('搜索出错:', error);
        throw error;
    }
}

/**
 * 处理搜索结果并生成AI回复
 * @param {string} query - 用户查询
 * @returns {Promise<string>} AI生成的回复
 */
async function getSearchBasedResponse(query) {
    try {
        // 显示搜索中的提示
        addMessage('assistant', `正在搜索最新信息: "${query}"...`, true);
        
        // 执行搜索
        const searchResults = await searchWithSerper(query);
        
        // 提取并格式化结果
        let context = '以下是最新的搜索结果：\n\n';
        
        // 添加知识图谱信息（如果有）
        if (searchResults.knowledgeGraph) {
            const { title, description } = searchResults.knowledgeGraph;
            context += `知识图谱: ${title} - ${description}\n\n`;
        }
        
        // 添加有机搜索结果
        if (searchResults.organic && searchResults.organic.length > 0) {
            context += '相关网页结果：\n';
            searchResults.organic.slice(0, 3).forEach((result, index) => {
                context += `${index + 1}. ${result.title}\n   链接: ${result.link}\n   摘要: ${result.snippet}\n\n`;
            });
        }
        
        // 构建提示词
        const prompt = `用户查询: ${query}\n\n${context}\n\n请根据以上信息回答用户的问题。如果信息不足，请说明。`;
        
        // 获取AI回复
        const aiResponse = await processWithLMStudio(prompt);
        
        // 添加引用来源
        let finalResponse = aiResponse;
        if (searchResults.organic && searchResults.organic.length > 0) {
            finalResponse += '\n\n参考来源：\n';
            searchResults.organic.slice(0, 3).forEach((result, index) => {
                finalResponse += `${index + 1}. [${result.title}](${result.link})\n`;
            });
        }
        
        return finalResponse;
        
    } catch (error) {
        console.error('获取搜索结果时出错:', error);
        return '抱歉，获取最新信息时出错。请稍后再试。';
    }
}

/**
 * 检查查询是否需要联网搜索
 * @param {string} query - 用户查询
 * @returns {boolean} 是否需要搜索
 */
function shouldSearchWeb(query) {
    // 检查是否需要最新信息的查询词
    const searchKeywords = [
        '最新', '新闻', '今天', '最近', '2025', '2024', '今年', '本月',
        '更新', '动态', '行情', '价格', '股价', '汇率', '天气', '比赛',
        '比分', '直播', '上映', '发布会', '发布会', '多少', '怎么', '如何',
        '为什么', '什么', '哪', '?', '？', '吗'
    ];
    
    return searchKeywords.some(keyword => query.includes(keyword));
}

// 在页面加载完成后初始化AI助手
document.addEventListener('DOMContentLoaded', () => {
    // 其他初始化代码...
    initAIAssistant();
});
